Adaptive Synchronization Techniques

ABSTRACT

Adaptive techniques for handling notifications and updating a directory of a file system in a graphical user interface of a computing environment. Adaptive techniques include determining that something has been potentially changed in the node. A time of the notification is obtained, and a preferred time value or trigger time for responding to the notification is calculated. The preferred time value may be calculated by adding an adjustment to a recorded time of the last synchronization performed on the directory. The adjustment may be calculated by weighting duration of synchronizations performed on the directory. Adaptive techniques may then compare the time value to the trigger time. If the time value is less than the trigger time, the display and directory are synchronized. Otherwise, a timer may be set to the trigger time, and synchronization of the display and directory may be delayed until the trigger time.

CROSS REFERENCE TO RELATED APPLICATIONS

This Application is a Continuation of application Ser. No. 10/877,125filed 25 Jun. 2004 by Peter McInerney having the same title as theinstant application. This application claims priority to applicationSer. No. 10/877,125 and incorporates it by reference in its entirety forall purposes.

FIELD OF THE INVENTION

The subject matter of the present disclosure generally relates totechniques for controlling operation (e.g., synchronization orup-dating) of a process related to a node in response to changes made tothe node that can cause the process to perform labor intensive work.More particularly, the subject matter of the present disclosure relatesto techniques for updating a graphical user interface (GUI) display of afile system directory by adaptively synchronizing the directory and theapplication having the GUI display when notifications of a change madeto the directory are received.

BACKGROUND OF THE INVENTION

Referring to FIG. 1, a file system 2 of a computing environment isschematically represented as a tree of directories 4 and files 6. Adirectory 4 is a special type of file maintained by the file system 2that contains a list of entries. A Finder 8 is an application of thecomputing environment that has a graphical user interface (GUI). Thegraphical user interface of the Finder 8 allows the user to view thedirectories 4 and files 6 in the file system 2. For example, the windowof the Finder 8 typically displays icons and file names and can displayother information about the files, such as file size, application, datelast saved, etc. To a user, entries of a directory 4 appear as foldersor files having the file names and other related information in theFinder 8. Actually, each entry of a directory 4 is a pointer pointingdirectly to a file 6 or to an entry in another directory 4.

Various processes in the computing environment can access and changedirectories 4 and files 6 of the file system 2. While the Finder 8 isopen, for example, other processes of the computing environment (e.g.,operators, tools, or applications) can manipulate the file system 2(e.g., add, delete, or edit files 6) so that the directory 4 of files 6displayed in the Finder 8 is not current. Maintaining an up-to-datedisplay of directories 4 and files 6 of the file system 2 in the Finder8 can be important. To keep the representation of the file system 2up-to-date in the Finder 8, some methods for synchronizing the Finder 8with changes to the directories 2 are used in the art.

One synchronizing method known in the art involves periodically pollinga directory 4 at regular intervals to keep the representation of thedirectory 4 up-to-date in the Finder 8. The periodic polling involvesrereading all the data from the directory 4 and updating the display ofthe Finder 8 according to some schedule. Unfortunately, such polling isinefficient because intensive input and output operations (e.g.,touching the disk of the hard drive and re-reading directories) must beperformed even if no files 6 have been changed in the directory 4. Thus,the periodic polling may do unnecessary and intensive work. In addition,polling can be ineffective because the Finder 8 is not updated betweenintervals when an operator, tool, or application may need an up to datedirectory.

Another synchronizing method involves detecting specific triggers thatindicate the user's current interests in files 6 of the directory 4 andpossible changes to those files 6. This synchronizing method is similarto what is performed in Mac OS X Panther and earlier versions of Mac OSX. The triggers can be generated by opening the attached folder, closingthe window of the attached folder, moving or resizing the window of theattached folder, placing items into the attached folder, or removingitems from the attached folder. The triggers can trigger re-reading of adirectory to update the Finder 8. This synchronizing method has theadvantage of limiting the polling of the directory 4 and updating theFinder 8 only when the user indicates interest. Unfortunately, changeswill not be noticed until there is user-action. The Finder 8 cannotnotice a change in a directory 4 unless a trigger is assigned to aparticular action, and other processes (users on a network, tools, orapplications) lacking triggers may operate in the background of thecomputer system and may not trigger the update of the finder.

The subject matter of the present disclosure is directed to overcoming,or at least reducing the effects of, one or more of the problems setforth above.

SUMMARY OF THE PRESENT DISCLOSURE

In one embodiment of the present disclosure, an apparatus and method ofhandling a notification with a service in a computing environment isdisclosed. The computing environment has a process and a node. Theservice performs an operation between the process and the node inresponse to one or more notifications. The notifications can begenerated in response to a change at least potentially made to the node,generated when another process performs an action related to the node,or generated in response to a triggered timer.

In one example, the node can be a directory of a file system, and theprocess can be a graphical user interface for displaying contents of thedirectory. A notification can be generated when a change is made to thedirectory. Thus, the operation can involve synchronizing the graphicaluser interface and the directory by updating the display of thedirectory in the graphical user interface.

In another example, the node can be a property store in which anattribute of an object resides, and the process can be capable ofchanging the attribute of the object. A notification can be generatedwhen a change is made to an attribute of an object. Thus, the operationbetween the process and the property store can involve updating theattribute of the object in the property store.

In the present embodiment, the disclosed apparatus and method involvesobtaining a current time value of a notification and calculating apreferred time value for responding to the notification. The currenttime value is then compared to the preferred time value, and theoperation between the process and the node is initiated based on thecomparison of the current time value to the preferred time value.

The preferred time value can be calculated by adding an incrementalvalue to the previous time value. The incremental value can becalculated by weighting a previous duration value, where the previousduration value substantially represents an amount of time for performingat least one previous operation on the node. For example, the previousduration value can substantially represent a discrete amount of time forperforming one previous operation on the node. Alternatively, forexample, the previous duration value can substantially represent anaverage amount of time for performing a plurality of previous operationson the node. Weighting the duration value can involve multiplying afactor times the duration value. The factor can be based on a definedthreshold or on a priority assigned to the node.

Accordingly, the operation can be initiated when the current time valueis at least greater than the preferred time value. In contrast, theoperation can be delayed until the preferred time value when the currenttime value is at least less than the preferred time value. To delay theoperation until the preferred time value, a timer can be set to triggerat the preferred time value.

This and other embodiments of the present disclosure can be implementedas a computer-readable medium having computer executable instructions.

In another embodiment of the present discloser, an apparatus and methodof performing an operation on a node in a computing environment isdisclosed. The method includes generating a notification related to thenode and obtaining a current time value of the notification. The methodfurther involves calculating a preferred time value for responding tothe notification and comparing the current time value to the preferredtime value. The, the operation on the node is initiated based on thecomparison of the current time value to the preferred time value.

In another embodiment of the present disclosure, an apparatus and methodof handling a notification with a service in a computing environment isdisclosed. The computing environment has a process and a node. Theservice performs an operation between the process and the node inresponse to one or more notifications. When a notification is received,a latency value and a duration value are determined. The latency valuesubstantially represents an expanse of time from a time value of oneprevious operation performed on the node to a current time value of thenotification. The duration value substantially represents an amount oftime for performing at least one previous operation on the node. Then, aratio of the duration value to the latency value is determined. If theratio is at least greater than a defined threshold, then operationbetween the process and the node is initiated. However, the operationbetween the process and the node can be delayed if the ratio is at leastless than the defined threshold.

In another embodiment of the present disclosure, a service forperforming an operation between a process and a node in a computingenvironment is disclosed. The service receives one or more notificationsrelated to the node, and the service handles the one or morenotification according to a method. The method of handling the one ormore notifications involves obtaining a previous time value, and aprevious duration value. The previous time value is from a previousoperation performed on the node. The previous duration valuesubstantially represents an amount of time for performing at least oneprevious operation on the node. An incremental value is then calculatedby multiplying a weighted criterion times the previous duration value.In addition, a trigger time for responding to the notification iscalculated by adding the incremental value to the previous time value.Then, a current time value is compared to the trigger time. If thecurrent time value is at least greater than the trigger time, theoperation is initiated. If the current time value is at least less thanthe trigger time, then the operation is delayed until the preferred timevalue.

The foregoing summary is not intended to summarize each disclosed orpotential embodiment or every aspect of the present disclosure.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing summary, preferred embodiments, and other aspects ofsubject matter of the present disclosure will be best understood withreference to a detailed description of specific embodiments, whichfollows, when read in conjunction with the accompanying drawings, inwhich:

FIG. 1 illustrates a schematic tree of a file system and illustrates aFinder according to the prior art.

FIG. 2 illustrates a software stack having an adaptive synchronizingservice and data structures according to certain teachings of thepresent disclosure.

FIG. 3 schematically illustrates an embodiment of the adaptivesynchronizing service and data structures according to certain teachingsof the present disclosure.

While the disclosed adaptive synchronizing service and techniques aresusceptible to various modifications and alternative forms, specificembodiments thereof have been shown by way of example in the drawingsand are herein described in detail. The figures and written descriptionare not intended to limit the scope of the inventive concepts in anymanner. Rather, the figures and written description are provided toillustrate the inventive concepts to a person skilled in the art byreference to particular embodiments, as required by 35 U.S.C. §112.

DETAILED DESCRIPTION A. Software Stack

Referring to FIG. 2, an example of a software stack 10 is illustratedhaving an adaptive synchronizing service, system, or process 100according to certain teachings of the present disclosure. Embodiments ofthe service 100 disclosed herein include software. As such, the softwarestack 10 of FIG. 1 expresses an embodiment of common computing softwarearchitecture in a plurality of layers 20, 30, and 40. These layers 20,30, and 40 are not intended to be exclusive in any way but ratherillustrative. This is especially true for layer-type diagrams ofsoftware stacks, which software developers tend to express in somewhatdiffering ways. Some layers of software and firmware are omitted fromthe software stack 10 of FIG. 1. The illustrated software stack 10 isintended to imply that software elements shown in a layer use resourcesfrom the layers below and provide services to layers above. However, inpractice, not all components of a particular software element may behaveentirely in that manner.

With those caveats, the software stack 10 includes a file system layer20, an application frameworks and services layer 30, and an applicationlayer 40. The file system layer 20 includes a plurality of directories22, which are maintained by the file system 20 of the computingenvironment. The directories 22 contain entries (not shown) that arepointers pointing to files or to entries in other directories. Layer 30is an amalgamation of functions typically expressed as two layers (e.g.,applications frameworks layer and application services layer). Forpurposes of our discussion, both these layers provide high-level andoften functional support for application programs that reside in thehighest layer 40. One application in the application layer includes afinder application (“Finder”) 42. The Finder 42 is a softwareapplication having a graphical user interface for displaying contents ofthe file system 20. For example, the Finder 42 can display files in thedirectories 22 with icons and can give various information on the file,such as name, file size, last update, creating application, etc.

In addition, data structures 70 are illustrated in FIG. 2. The datastructure 70 can be a table, tree, or other data file attached to theframeworks and service layer 30 and residing in memory of the computingenvironment. The data structures 70 store data on the directories 22 forthe service 100. As described in more detail below, the data stored inthe data structures 70 includes a token identifying a specific directory22, a time representing when the last synchronization of the specificdirectory 22 was performed, a duration representing the amount of timeor average time required to perform the last synchronization(s) on thespecific directory 22, and a Boolean value representing whether aself-generated synchronization has been requested for the directory 22as described below.

B. Embodiment of Adaptive Synchronizing Service

The adaptive synchronizing service 100 is a service within theapplication frameworks and services layer 30. The service 100 performsadaptive techniques for handling notifications according to certainteachings of the present disclosure. Using the adaptive techniques, theservice 100 updates the representation of the directories 22 in theFinder 42 when files (not shown) in the directories 22 of the filesystem 20 are changed. In the adaptive techniques, a notification 62from a notification system 60 is generated when something in the filesystem 20, such as contents of the directory 22 have been changed. Thesynchronizing service 100 then adaptively determines whether to responddirectly to the notification 62 by synchronizing the Finder 42 and thedirectory 22 or whether to delay synchronization until a later time. Theadaptive determination by the service 100 can depend on the priority ofthe directory 22 or on the available resources of the computingenvironment.

1. Notification System

When something in a directory 22 is changed by a process, action,application, or the like 61, a notification 62 is generated from thenotification system 60. Preferably, directories 22 of the file system 20are registered so that changes to them prompt the notification system 60to generate a notification 62. For example, the notification 62 isgenerated when an application changes something in the directory 22, orthe notification 62 is self-generated by the service 100. Thenotification 62 only notifies the service 100 that something in thedirectory 22 has been changed and does not indicate what has beenchanged in the directory 22, which maintains efficiency of the computersystem by limiting memory and processing usage.

The notification system 60 is preferably an open source notificationsystem, and the notification system 60 and notifications 62 can besimilar to notifications for a computing environment that are known inthe art. In one embodiment, for example, the notification system 60 andnotifications 62 can be based on the kqueue mechanism, which is ageneric event delivery facility known in the art. Teachings of thekqueue mechanism can be found in the paper, “Kqueue: A Scalable andGeneric Event Delivery Facility,” which was presented at the BSDCon 2000conference in Monterey, Calif. by Jonathan Lemon and which isincorporated herein by reference. The notifications 62 can communicatekernel-to-application and application-to-application events.Kernel-based notifications provide the opportunity for significantperformance gains, by eliminating the need for time-consuming pollingand making it easy for tools and services to find out about such itemsas changed directory files and network disconnects.

In general, the service 100 synchronizes the directory 22 and the Finder42 by accessing (66) the specified directory 22 and updating (68) thecontents of the specified directory 22 in the Finder 42. The amount ofwork needed to synchronize a directory 22 is substantially proportionalto the contents in the directory 22 because the entire contents of thedirectory 22 must be re-read when synchronizing. If the service 100 wereto directly synchronize the directory 22 and the Finder 42 after eachnotification 62, the service 100 could very quickly perform nothingother than synchronizing a large directory 22 that is changingfrequently. Therefore, the service 100 is preferably designed to handlepotentially large sizes and/or frequently changing directories 22. Toimprove effectiveness and efficiency, the service 100 preferablyincludes adaptive techniques for tracking the history of previoussynchronizations of the directories 22 and for synchronizing thedirectories 22 according to defined criteria based on that trackedhistory.

2. Responding to Notifications

As noted above, the notification 62 simply notifies the service 100 thatsomething in the directory 22 has been changed or that synchronizationof the directory is due. Before automatically synchronizing thedirectory 22, however, the adaptive service 100 accesses (64) data in aspecified data structure 71 for the directory indicated in thenotification 62. The data structure 71 is tagged for a specificdirectory 22 using a pointer or other token. The notification 62 isgiven the token of the registered directory 22 when generated so thatthe specific data structure 71 for the registered directory 22 can bereadily accessed. From the data structure 71, the service 100 obtains aprevious synchronization time and obtains a duration of one or moresynchronizations previously performed on the registered directory 22.The duration can simply be the last duration taken to synchronize thedirectory 20, can be a moving average of the last few synchronizationsof the directory 22, or can be a total time spent synchronizing alldirectories 22.

The service 100 then compares a current time to the previoussynchronization time to calculate a latency period (i.e., the timebetween the present notification 62 and the last synchronization of thedirectory 22). The service 100 uses the duration of the lastsynchronization to estimate what a current duration would be required toread the same directory 22. Given this data, the service 100 calculatesestimates a percentage of resources, such as CPU usage, that would beused if the directory 22 and the Finder 42 were immediatelysynchronized. The calculated percentage is then compared to a predefinedthreshold to determine whether synchronization can be done immediatelyor be delayed. The following equation may be used to determine whetherthe calculated percentage is below a predefined threshold:

${{{Threshold}\mspace{14mu} \%} \geq {\frac{Duration}{Latency}*100}},$

where “Duration” is the amount of time or average time for performingthe last synchronization on the directory 22 and where “Latency” is thedifference between the current time and the time of the lastsynchronization was performed on the directory 22. If the percentage of“Duration over Latency” is below the predefined threshold, then thesynchronization proceeds. For example, suppose the “Duration” of thelast synchronization task of reading the directory 22 was one second. Ifthe predefined threshold value is set to be 10%, then the service 100will preferably respond to the current notification only after a“Latency” period of 10seconds to maintain the threshold value of 10%.Thus, if the current notification is received ten seconds or more fromthe time the last synchronization was performed, the service 100 willread (66) the directory 22 to update (68) the Finder 42. Every time theservice 100 performs a synchronization, the service 100 updates the datain the data structure 70 to reflect the most recent time of lastsynchronization and most recent duration for performing thesynchronization on the node.

However, suppose the “Duration” of the last synchronization task ofreading the directory 22 is one second and the “Latency” (time sincelast reading the directory) is two seconds, then responding to thenotification 62 would give a response value of 50%, which is well abovethe threshold value (e.g., 10%) preferred by the service 100. In thiscase, the service 100 would either ignore the current notification 62 ordelay synchronization. If the threshold is exceeded, it is possible toinvert the calculation and determine at what future time thesynchronization would cause the CPU usage to drop below the thresholdvalue. As noted in the above example, if the “Duration” of the lastsynchronization is one second and the predefined threshold value is 10%,then the service 100 would preferably respond to a notification onlyafter ten seconds. In this case, a timer can be set to triggersynchronization at the appropriate time (e.g., within ten seconds) anddefer the synchronization until then. If a notification is received inthe interim and the timer is still pending on that directory, theinterim notification can simply be ignored.

The net effect is that if the service 100 receives change notifications62 at a low rate, then the service 100 performs the synchronizationsimmediately. Yet, if the service 100 receives notifications 60 morefrequently, the amount of effort the service 100 devotes tosynchronizing the directories 22 is essentially capped. There may besome lag in changes reflected in the Finder 42 because the changes willbe synchronized in batches. However, this adaptive technique will neverlose changes to the directory 22, because synchronization between thedirectory 22 and the Finder 42 at any particular time will reflect allintervening changes of the directory 22.

This adaptive synchronizing technique overcomes some of the problems ofperiodic polling techniques and user-triggered polling techniquesdescribed above in the Background Section of the present disclosure. Inparticular, the adaptive technique of the service 100 overcomes theinefficiencies that can cause repeated up-dates of the directories 22 inFinder 42 when changes have not even occurred in the directories 22.Moreover, the adaptive technique of the service 100 overcomes theinefficiencies by placing a cap on the total percentage of availableresources that are devoted to synchronizing.

E. Preferred Embodiment of Adaptive Synchronizing Service and DataStructure

Referring to FIG. 3, an embodiment of the adaptive synchronizing service100 and a data structure 70 according to certain teachings of thepresent disclosure are schematically illustrated. The service 100includes a Notification Handler 110, an Adjusted Sync Function 120, aSynchronize Function 130, and a Timer Function 140. The data structure70, schematically shown in tabular form, includes a representation ortoken of a node (“node” field 72), a time for the last synchronization(“Last Sync Time”) field 74, a Boolean value, e.g., TRUE or FALSE,indicating whether a future synchronization is requested for the node(“Sync Requested” field 76), and a duration of the synchronizationsperformed on the node (“Duration” field 78). In the discussion thatfollows, a node represents a class of object to be synchronized. Forexample, a node may be a directory, a property store, the visiblecontents of a window, or any data structure that needs to be updatedfrom external data. In the discussion that follows, time represents someunit of time measurement, such as clock time, CPU cycles, or other timemeasure.

1. Calling Notification Handler

The Notification Handler 110 receives a change notification 62 whensomething has been at least potentially changed in a node (e.g.,directory of the file system). As noted above, the notification system60 can generate the notification 62 when a process, action, application,or the like 61 alters or manipulates the node. For example, anapplication or some other process making a change to a registereddirectory can cause the notification system 60 to generate the changenotification 62. Alternatively, the Notification Handler 110 can becalled when a set timer triggers and causes the notification system 60to generate a notification 62, such as discussed below. The notification62 simply indicates that a change has been made and carries no “payload”or additional information related to the change.

2. Calculating an Adjusted Sync Quanta

When called, the Notification Handler 110 obtains the Last Sync Timefrom field 74 of the data structure 70 and calculates an Adjusted SyncQuanta or incremental time value using the Adjusted Sync Function 120.The Adjusted Sync Quanta is used to calculate a preferred time value orTrigger Time, which is then used to determine whether synchronization ofthe node is due. In the Adjusted Sync Function 120, the Adjusted SyncQuanta is a time value calculated using available data in the datastructure 70 and a weighted criterion for the specific node. Inparticular, the Adjusted Sync Quanta is calculated by multiplying anadjustment factor (weighted criterion) with the Duration from the field78 of the data structure 70 for the node. The adjustment factor(weighted criterion) can be fixed. Alternatively, the adjustment factor(weighted criterion) can be dynamic and can be changed in accordancewith changes in the computing environment. The changes in the computingenvironment can include, but are not limited to, changes in anapplication associated with the node, fluctuations in availableprocessing resources, varying interests of the user, operations ofvarious processes on the specific node, the traffic of a network system,availability of a server, or input/output operations performed on a harddisk or other memory device.

In one embodiment, the adjustment factor can be based on a priority orimportance of a specified node (e.g., directory). For example, a GUIapplication in the computing environment can display multiple windowswith each window showing the contents of a different directory. Tobetter allocate available processing time, it is preferred tosynchronize a foreground window more frequently than a backgroundwindow. Therefore, the different nodes (e.g., directories) can beassigned priorities based on their importance (i.e., whether thedirectory is displayed in a foreground window or a background window ofthe GUI application). Priority of a node can be fixed or can bedynamically assigned based on changes in the computing environment.

In an alternative embodiment, the adjustment factor can be a thresholdvalue based on a preferred consumption of processing recourses used tosynchronize the node. For example, the threshold value can be based onthe time required to synchronize the node relative to the time betweensynchronizations performed on the node. The threshold value can be fixedfor all nodes or can be dynamically assigned in a given instance basedon changes in the computing environment.

The calculated Adjusted Sync Quanta is preferably greater than or equalto a predefined minimum value. Therefore, the Adjusted Sync Quanta iscompared to a minimum quanta value. If the Adjusted Sync Quanta isgreater than the minimum quanta value, then the Adjusted Sync Quanta isreturned to the Notification Handler 110. If the Adjusted Sync Quanta isnot less than the minimum quanta value, then the Adjusted Sync Quanta isset to the minimum quanta value and is returned to the NotificationHandler 110. Making the Adjusted Sync Quanta not less than minimumquanta value ensures that the same node is never synchronized any moreoften than specified by the minimum quanta.

3. Calculating a Trigger Time

The Notification Handler 110 calculates a Trigger Time by adding theLast Sync Time in field 74 of the data structure 70 using the AdjustedSync Quanta returned from the Adjusted Sync Function 120. The TriggerTime represents the preferred time from the last synchronization of thenode at which synchronizing the node would best meet the preferredpriority of the node or the preferred usage of processing resources. TheNotification Handler 110 then obtains a current time and compares theTrigger Time to the current time. If the current time is greater thanthe Trigger Time, the Notification Handler 110 sets a Sync Request infield 76 of the data structure 70 to FALSE, and the node is synchronizedusing the Synchronize Function 130 described below. Otherwise, if asynchronization is not already scheduled to occur at a set trigger time(i.e., the Sync Request in field 76 of the data structure 70 is notTRUE), then the Sync Request is set to TRUE. In addition, a timer forhandling the synchronization request is set to the Trigger Time usingthe Timer Function 140 described below.

4. Synchronize Function

As noted above, the Notification Handler 110 accesses the SynchronizeFunction 130 if the current time is greater than the Trigger Time, whichmeans synchronizing the node is currently warranted. The SynchronizeFunction 130 actually does the necessary synchronization of the node(e.g., directory) and is only called from Notification Handler 110.During synchronization, a start time is set to a current time obtained.A routine then does the actual synchronization on the node. For example,the synchronization can involve reading a directory of a file system andupdating a graphical user interface to reflect the new reading of thedirectory, as described in previous examples. Although the presentembodiment involves a synchronizing operation (e.g., reading a directoryand updating a graphical user interface), the adaptive techniques of thepresent invention can involve operations other than synchronizing. Forexample, the other operations can include, but are not limited to,updating the attributes in a property store, or redrawing the contentsof a window in response to changes in the underlying data that itdisplays.

When synchronization is complete, an end time is set to a subsequentcurrent time obtained. The start time determined previously is thenstored in the data structure 70 as the Last Sync Time in field 74, andthe difference between the end time and the start time is applied to theDuration in field 78 of the data structure 70 for the node. For example,the difference can directly substitute a previous value for the Durationin field 78. Alternatively, the difference can be added to a value ofprevious synchronizations stored in an accumulative field (not shown) ofthe data structure 70 and divided by a total number of synchronizationsstored in another field (not shown) to determine a running average forstoring as the Duration in field 78.

5. Timer Function

As noted above, the Notification Handler 110 accesses the Timer Function140 if the Sync Requested in field 76 of the data structure 70 waspreviously not TRUE. The Timer Function 140 sets a timer for handlingthe requested synchronization. If the Notification Handler 110 receivesan interim notification 62 while the timer is pending, the NotificationHandler 110 can first determine if a Sync Request in field 76 of thedata structure is TRUE. If the request is TRUE, then the NotificationHandler 110 recognizes that a timer and a request for performingsynchronization are already pending. Therefore, the Notification Handler110 can ignore the interim notification 62. In the Timer Function 140,the timer triggers when a current time equals the stored Trigger Time,causing the Notification Handler 110 to perform its algorithm. Forexample, triggering of the timer can cause the notification system 60 togenerate a new notification 62 that is received by the NotificationHandler 110.

6. Exemplary Code

Exemplary or pseudo code for performing adaptive techniques for handlingnotifications and synchronizing according to certain teachings of thepresent disclosure is provided below. In the implementation disclosedherein for synchronizing file systems, multiple threads are used, andtechniques known in the art involving locking primitives are used toensure correct behavior of the multiple threads. For clarity, theexemplary code omits details that can be inferred from the presentdisclosure or that can be specific to a particular implementation. Suchdetails fall within the purview of a person skilled in the art ofprogramming. In the exemplary code, a node represents a class of objectto be synchronized (e.g., directory or property store). In the exemplarycode, time, which is also used for durations, represents some unit oftime measurement. For example, time can be clock time, CPU cycles, orother time measurement used in computing.

// Node represents the class of the object to be // synchronized. Timerepresents some unit of time // measurement and is also used fordurations. //-------------------Get-Set last SyncTime------------- //Get and set the last sync time for node. This time is // considered afield of node. void SetLastSyncTime( Node node, Time time ); TimeGetLastSyncTime( Node ); //-------------------Get-Set LastSyncDuration------------- // Get and Set the last SyncDuration. TheDuration returned // may in fact be the actual duration for the lastsync of // node or it could be running average of the last few syncs //of node or it could even be a duration which is a running // average ofall syncs of all nodes. This information is // considered a storedfield, either of node or globally // available. voidSetLastSyncDuration( Node node, Time time ); Time GetLastSyncDuration(Node ); //---------------------Get-Set SynchRequest----------------- //Get and set a flag that indicates that a sync timer // already exists.This is considered a field of node. Boolean GetSyncRequested( Node node); void SetSyncRequested( Node node, Boolean requested );//--------------------GetAdjustedSyncQuanta---------------- // Return atime based on available data and the specific // node that specifies theadjusted quanta. The returned // quanta is always greater than or equalto a pre specified // minimum quanta. Time GetAdjustedSyncQuanta( Nodenode ) {    //---------------------GetAdjustment-------------------   // GetAdjustment may return a simple constant such as    // 10 whichwould correspond to a 10% threshold or it    // could return a differentvalue depending on whether    // the node was considered high priorityor not. For    // example, if the active window was showing node it   // could be higher priority than if node was shown in a //   background window.    int factor = GetAdjustment( node );    TimeadjustedQuanta = factor * GetLastSyncDuration( node );    return (adjustedQuanta > minimumQuanta) ? adjustedQuanta :    minimumQuanta;   } //---------------------Timer----------------------- // Set a timerto call NotificationHandler at the // triggerTime. This will ultimatelycause Synchronize( node // ) to be called at that time. voidSetTimerToHandleSyncRequest( Node node, Time triggerTime );//--------------------Synchronize--------------------------- //Synchronize does the necessary synchronization. It is // only evercalled from NotificationHandler void Synchronize( Node node ) {    TimestartTime = GetCurrentTime( );    DoSync( node ); // does the actualsyncing    Time endTime = GetCurrentTime( );    SetLastSyncTime( node,startTime );    SetLastSyncDuration( node, endTime − startTime ); }//----------------NotificationHandler----------------------- //NotificationHandler is called when a lower level change // notificationoccurs or as a result of a self generated // notification that occurswhen the set timer fires. void NotificationHandler( Node node ) {   Time lastSyncTime = GetLastSyncTime( node );    TimeadjustedSyncQuanta = GetAdjustedSyncQuanta(node);    Time triggerTime =lastSyncTime + adjustedSyncQuanta;    Time currentTime = GetCurrentTime();    //-----------------------------------------------------    // Ifwe have exceeded the trigger threshold then sync    // right away    //----------------------------------------------------    if(currentTime > triggerTime )    {       SetSyncRequested( node, false );      Synchronize( node );    }   //----------------------------------------------------    //Otherwise if we haven't already got a sync scheduled    // set one tofire at the trigger time   //----------------------------------------------------    else if(!GetSyncRequested( node ) )    {       SetSyncRequested( node, true );       SetTimerToHandleSyncRequest( node, triggerTime );    } }

F. Implementations other than Synchronizing Directory and an Application

The disclosed adaptive techniques for handling notifications are notrestricted to synchronizing or updating directories of a file system anda graphical user interface as disclosed in the exemplary implementationof the present disclosure. Rather, the disclosed adaptive techniques forhandling notifications can be applied to any system where low-levelnotifications can cause a recipient (e.g., process, user interface,etc.) of the notifications to perform unbounded work.

In another example implementation, the adaptive techniques for handlingnotifications of the present disclosure can be used when attributesassociated with a file or object are changed. The attributes typicallyreside in a property store of the computing environment. The propertystore is a database that contains various attributes of the objects.When a user changes an attribute, such as the label color, of an object,the entire property store typically must be updated (i.e., “writtenout”). Therefore, making a small attribute change can result in anintensive response by a recipient process because the property store isoften large. Certainly, the property store encompasses more than theattribute that has been changed. In this situation, the adaptivetechniques of the present disclosure can be useful to prevent unbounded,inefficient work in updating or writing out the properties store.

When a user sets a label color, for example, a notification can begenerated in response. When receiving the notification, the adaptivetechniques of the present disclosure can determine whether to write outthe property store immediately or to delay responding to the changedattribute until a later time. The time required (duration) for writingof the property store the last time an attribute was changed can bestored in a data structure for the property store. The adaptivetechniques can then calculate the amount of time (latency) between thecurrently requested attribute change and the last time the propertystore was written out. Then, the adaptive techniques can determine theratio of the duration over the latency and compare the ratio to apredefined threshold. If the requested change is premature (i.e., theratio exceeds the predefined threshold), the attribute change can bestored in memory and writing out the property store can be delayed.Subsequent changes to attributes can be stored until the ratio does notexceed the predefined threshold or until a set timer triggers theprocess of writing out the property file. In this way, the propertystore is written out with all of the changed attributes. In addition,the CPU usage can be controlled and any repeated, expensive writing outof the property store can be minimized when small changes or frequentchanges are made to the attributes of the property store.

F. Conclusion

The present disclosure amply illustrates to a computer programmer ofskill how to make and use the disclosed adaptive techniques for handlingnotifications and the accompanying user interfaces and other functionalaspects. Therefore, programming such techniques, accompanying userinterfaces, and other functional aspects is a routine matter to acomputer programmer of skill and can be accomplished using manydifferent programming languages and within the context of many differentoperating systems. Of course, the disclosed techniques would beultimately coded into a computer code and stored on a computer-readablemedia, such as a compact disk, a tape, stored in a volatile ornon-volatile memory, etc.

The foregoing description of preferred and other embodiments in thepresent disclosure is not intended to limit or restrict the scope orapplicability of the inventive concepts conceived by the Applicant. Inexchange for disclosing the inventive concepts contained herein, theApplicant desires all patent rights afforded by the appended claims.Therefore, it is intended that the appended claims include allmodifications and alterations to the full extent that they come withinthe scope of the following claims or the equivalents thereof.

1. A method of synchronizing a display representation of data withchanges associated with the data, the method comprising: determining achange to data, the data associated with a graphical representation ofthe data; calculating a preferred time value for synchronizing thegraphical representation with the determined change to data, thepreferred time value based at least partially on a duration of timetaken to perform at least one previous synchronization of the graphicalrepresentation; comparing a current time value to the preferred timevalue; and determining a synchronization time based on results of thecomparison, the synchronization time identifying a time to initiate asynchronization of the graphical representation.
 2. The method of claim1, wherein the data comprises attributes of files in a file system. 2.The method of claim 1, wherein the data comprises attributes of objectsin a property store.
 3. The method of claim 3, wherein the propertystore comprises a registry.
 4. The method of claim 4, wherein theregistry comprises a registry of a computer operating system.
 5. Themethod of claim 1, wherein determining a change comprises receiving anotification regarding a potential change to the graphicalrepresentation.
 7. The method of claim 1, wherein determining a changecomprises receiving a notification generated in response to a triggeredtimer.
 8. The method of claim 1, wherein calculating a preferred timevalue is based on a previous time value when the at least one previoussynchronization operation was completed.
 9. The method of claim 8,wherein calculating the preferred time value based on the previous timevalue comprises adding an incremental value to the previous time value,wherein the incremental value comprises a value calculated by weightinga previous duration value.
 10. The method of claim 1, wherein theduration of time taken to perform at least one previous synchronizationrepresents an average amount of time taken to perform a plurality ofdata synchronization operations.
 11. The method of claim 1, whereindetermining a synchronization time further comprises initiating thesynchronization immediately if the current time value is at least equalto the preferred time value.
 12. The method of claim 1, whereindetermining a synchronization time further comprises initiating thesynchronization after a delay until the preferred time value, when thecurrent time value is at least less than the preferred time value.
 13. Anon-transitory computer readable medium comprising executableinstructions stored thereon to cause a processor to: determine a changeto data, the data associated with a graphical representation of thedata; calculate a preferred time value for synchronizing the graphicalrepresentation with the determined change to data, the preferred timevalue based at least partially on a duration of time taken to perform atleast one previous synchronization of the graphical representation;compare a current time value to the preferred time value; and determinea synchronization time based on results of the comparison, thesynchronization time identifying a time to initiate a synchronization ofthe graphical representation.
 14. The non-transitory computer readablemedium of claim 13, wherein the data comprises attributes of files in afile system.
 15. The non-transitory computer readable medium of claim13, wherein the data comprises attributes of objects in a propertystore.
 16. The non-transitory computer readable medium of claim 15,wherein the property store comprises a registry.
 17. The non-transitorycomputer readable medium of claim 16, wherein the registry comprises aregistry of a computer operating system.
 18. The non-transitory computerreadable medium of claim 13, wherein the instructions to cause theprocessor to determine a change comprise instructions to cause theprocessor to receive a notification regarding a potential change to thegraphical representation.
 19. The non-transitory computer readablemedium of claim 13, wherein the instructions to cause the processor todetermine a change comprise instructions to cause the processor toreceive a notification generated in response to a triggered timer. 20.The non-transitory computer readable medium of claim 13, wherein theinstructions to cause the processor to calculate a preferred time valuecomprise instructions to calculate the preferred time value based on aprevious time value when the at least one previous synchronizationoperation was completed.